home *** CD-ROM | disk | FTP | other *** search
/ Amiga Games: 500 MB Amiga Software / 500 MB Amiga Software - Euber 130 - Amiga Games Disc & Mag.iso / userbox / publicdomain / tinymeter / source / tinymeter_main / initclean.c < prev    next >
C/C++ Source or Header  |  1995-11-16  |  14KB  |  441 lines
  1. #include "includes.h"
  2. #include "structs.h"
  3. #include <datatypes/datatypesclass.h>
  4. #include <datatypes/datatypes.h>
  5. #include <intuition/classes.h>
  6.  
  7. extern struct Library       *ShutdownBase;
  8. extern struct Library       *ScreenNotifyBase;
  9. extern struct Library       *RetinaBase;
  10. extern struct Library       *TimerBase;
  11. extern struct Library       *DataTypesBase;
  12. extern struct IntuitionBase *IntuitionBase;
  13. extern struct GfxBase       *GfxBase;
  14. extern struct ExecBase      *SysBase;
  15.  
  16. struct Gadget my_drag=
  17. {
  18.     NULL,
  19.     0,1,
  20.     0,0,
  21.     GFLG_GADGHNONE,
  22.     GACT_IMMEDIATE,
  23.     GTYP_SYSGADGET|GTYP_WDRAGGING,
  24.     0,
  25.     0,
  26.     0,
  27.  
  28.     0,
  29.     0,
  30.     2,
  31.     0
  32. };
  33.  
  34. struct Gadget my_close=
  35. {
  36.     NULL,
  37.     0,0,
  38.     16,16,
  39.     NULL,
  40.     GACT_IMMEDIATE,
  41.     GTYP_SYSGADGET|GTYP_CLOSE,
  42.     0,
  43.     0,
  44.     0,
  45.  
  46.     0,
  47.     0,
  48.     1,
  49.     0
  50. };
  51.  
  52. struct Gadget my_size=
  53. {
  54.     NULL,
  55.     0,0,
  56.     16,16,
  57.     GFLG_GADGHNONE,
  58.     GACT_IMMEDIATE,
  59.     GTYP_SYSGADGET|GTYP_SIZING,
  60.     0,
  61.     0,
  62.     0,
  63.  
  64.     0,
  65.     0,
  66.     3,
  67.     0
  68. };
  69.  
  70. extern struct tm_settings dftm;
  71.  
  72. extern UBYTE             numofvols;
  73. extern char             *LoadedVolList[64],
  74.                         *LoadedVolList_1[64];
  75. extern struct DateTime   dt;
  76.  
  77. UBYTE                    numoflines;
  78. struct Window           *my_window=0L;
  79. struct TextFont         *my_text_font=0L,
  80.                         *my_clock_font_1=0L,
  81.                         *my_clock_font_2=0L;
  82. struct RastPort         *my_rastport=0L,
  83.                          my_rp,
  84.                          my_rp_2;
  85. struct BitMap           *my_bitmap=0L,
  86.                         *my_b1=0L,
  87.                         *my_b2=0L,
  88.                         *my_b=0L;
  89. struct BitMapHeader     *my_header=0L;
  90. struct Screen           *my_pub_screen=0L;
  91. Object                  *my_dtobject=0L;
  92. UWORD                    yypos[32];
  93. UWORD                    xxpos[32];
  94. UBYTE                    were_on_public;
  95. ULONG                    gauge_x_pos,
  96.                          gauge_y_pos_2,
  97.                          gauge_x_size,
  98.                          gauge_y_size,
  99.                          info_x_size,
  100.                          texty,
  101.                          textdelta,
  102.                          space,
  103.                          space_x=0L,
  104.                          space_s=0L;
  105. UBYTE                    were_on_public;
  106. char                    *pubscreenadress=0L;
  107. extern ULONG             my_window_mask;
  108. BOOL                     InitIdle;
  109.  
  110.  
  111. renew_temp_bitmaps(WORD width, WORD height)
  112. {
  113.     if(my_b1){FreeBitMap(my_b1);my_b1=0L;};
  114.     if(my_b2){FreeBitMap(my_b2);my_b2=0L;};
  115.  
  116.     if(!(my_b1=(struct BitMap *)AllocBitMap(width,height+textdelta,my_pub_screen->RastPort.BitMap->Depth,BMF_CLEAR|BMF_DISPLAYABLE,0L)))cleanexit();
  117.     if(!(my_b2=(struct BitMap *)AllocBitMap(width,height+textdelta,my_pub_screen->RastPort.BitMap->Depth,BMF_CLEAR|BMF_DISPLAYABLE,0L)))cleanexit();
  118.  
  119.     InitRastPort(&my_rp);   my_rp.BitMap  =(struct BitMap *)my_b1;
  120.     InitRastPort(&my_rp_2); my_rp_2.BitMap=(struct BitMap *)my_b2;
  121. }
  122.  
  123. dogetwidesttext(char *text)
  124. {
  125.     int dummy_1;
  126.     if((dummy_1=TextLength(my_rastport,text,my_strlen(text))+4+BSIZX)>gauge_x_pos) gauge_x_pos=dummy_1;
  127. }
  128.  
  129. /*
  130.  
  131. #define MAX_SERS 8
  132.  
  133. struct MsgPort  *SerialMP[MAX_SERS];         
  134. struct IOExtSer *SerialIO[MAX_SERS];    
  135. BOOL   device_present[MAX_SERS];
  136.  
  137. init_serial()
  138. {
  139.     int k;
  140.     for(k=0;k<MAX_SERS;k++)
  141.     {
  142.         device_present[k]=FALSE;
  143.         if(dftm.Devices[0][k]!=0)
  144.         {
  145.             if (SerialMP[k]= CreatePort(0,0) )
  146.             {
  147.                 if (SerialIO[k]=(struct IOExtSer *) CreateExtIO(SerialMP[k],sizeof(struct IOExtSer)))
  148.                 {
  149.                     SerialIO[k]->io_SerFlags=SERF_SHARED;
  150.                     if (!OpenDevice(&dftm.Devices[k][0],0L,(struct IORequest *)SerialIO[k],0) )device_present[k]=TRUE;
  151.                 }
  152.             }
  153.         }
  154.     }
  155. }
  156.  
  157. free_serial()
  158. {
  159.     int k;
  160.     for(k=0;k<MAX_SERS;k++)
  161.     {
  162.         if(SerialIO[k])
  163.         {
  164.             if (device_present[k])
  165.             {
  166.                 CloseDevice((struct IORequest *)SerialIO[k]);
  167.                 SerialIO[k]=0L;
  168.             }
  169.             DeleteExtIO((struct IORequest *)SerialIO[k]);
  170.         }
  171.         if(SerialMP[k])
  172.         {
  173.             DeletePort(SerialMP[k]);
  174.             SerialMP[k]=0L;
  175.         }
  176.     }
  177. }
  178.  
  179. */
  180.  
  181. open_new_window(WORD x, WORD y, WORD xsiz, WORD ysiz)
  182. {
  183.     if(!(my_window=(struct Window *) OpenWindowTags(0,
  184.                                                     WA_Left,            x,
  185.                                                     WA_Top,             y,
  186.                                                     WA_Width,           xsiz,
  187.                                                     WA_AutoAdjust,      TRUE,
  188.                                                     WA_MaxWidth,        28800,
  189.                                                     WA_MaxHeight,       ysiz,
  190.                                                     WA_MinHeight,       ysiz,
  191.                                                     WA_Height,          ysiz,
  192.                                                     WA_MinWidth,        50,
  193.                                                     WA_Flags,           WFLG_BORDERLESS|WFLG_SMART_REFRESH|WFLG_REPORTMOUSE|WFLG_RMBTRAP,
  194.                                                     WA_PubScreenName,   pubscreenadress,
  195.                                                     WA_Title,           0,
  196.                                                     TAG_DONE
  197.                                                    ))) {exit(1);};
  198.  
  199.     my_drag.Width=   my_window->Width;
  200.     my_drag.Height=  my_window->Height-17;
  201.     my_size.TopEdge= my_window->Height-16;
  202.     my_size.LeftEdge=my_window->Width -16;
  203.     if(dftm.WindowMove<2)
  204.     {
  205.         AddGadget(my_window,&my_drag, (UWORD)0);
  206.         AddGadget(my_window,&my_size, (UWORD)0);
  207.         AddGadget(my_window,&my_close,(UWORD)0);
  208.     }
  209.     ModifyIDCMP(my_window,IDCMP_NEWSIZE|IDCMP_CLOSEWINDOW|IDCMP_CHANGEWINDOW|IDCMP_VANILLAKEY|IDCMP_MOUSEBUTTONS|IDCMP_SIZEVERIFY);
  210.     my_rastport=my_window->RPort;
  211.     SetFont(my_rastport,my_text_font);
  212.     SetDrMd(my_rastport,JAM1);
  213.     my_window_mask  = 1L << my_window->UserPort->mp_SigBit;
  214.     info_x_size     = ((my_window->Width)/dftm.colums)-(BSIZX<<1);
  215.     if((dftm.back_pic==1)&&(DataTypesBase)) load_background();
  216. }
  217.  
  218. get_min_size()
  219. {
  220.     struct IntuiMessage *m;
  221.     if(dftm.DisplayDIGITAL | dftm.DisplayDATE)
  222.     if(my_window->Width<MAX(my_clock_font_1->tf_XSize*8+my_clock_font_2->tf_XSize*9+32,gauge_x_pos+64))
  223.     {
  224.         ChangeWindowBox(my_window,my_window->LeftEdge,my_window->TopEdge,MAX(32+my_clock_font_1->tf_XSize*8+my_clock_font_2->tf_XSize*9,gauge_x_pos+64),my_window->Height);
  225.         for(;;)
  226.         {
  227.             m=(struct IntuiMessage *)GetMsg( my_window->UserPort );
  228.             if(m->Class==IDCMP_CHANGEWINDOW) break;
  229.         }
  230.         renew_temp_bitmaps(my_window->Width,my_window->Height);
  231.         my_drag.Width   =my_window->Width;
  232.         my_drag.Height  =my_window->Height-17;
  233.         my_size.TopEdge =my_window->Height-16;
  234.         my_size.LeftEdge=my_window->Width-16;
  235.     }
  236.     my_window->MinWidth=MAX(dftm.DisplayDIGITAL | dftm.DisplayDATE ? my_clock_font_1->tf_XSize*8+my_clock_font_2->tf_XSize*9+32 : 0,gauge_x_pos+64);
  237.     my_window->MinWidth=MAX(((gauge_x_pos+BSIZX+32)*dftm.colums),my_window->MinWidth);
  238.     if(my_window->Width<((gauge_x_pos+BSIZX+32)*dftm.colums))
  239.     {
  240.         ChangeWindowBox(my_window,my_window->LeftEdge,my_window->TopEdge,((gauge_x_pos+BSIZX+32)*dftm.colums),my_window->Height);
  241.         for(;;)
  242.         {
  243.             m=(struct IntuiMessage *)GetMsg( my_window->UserPort );
  244.             if(m->Class==IDCMP_CHANGEWINDOW) break;
  245.         }
  246.         renew_temp_bitmaps(my_window->Width,my_window->Height);
  247.         my_drag.Width   =my_window->Width;
  248.         my_drag.Height  =my_window->Height-17;
  249.         my_size.TopEdge =my_window->Height-16;
  250.         my_size.LeftEdge=my_window->Width-16;
  251.     }
  252. }
  253.  
  254. open_window()
  255. {
  256.     UBYTE k;
  257.     ULONG dummy_1;
  258.     WORD  win_height;
  259.  
  260.     pubscreenadress=(char *)&dftm.pubscreen_name[0];
  261.     if( my_pub_screen=(struct Screen *)LockPubScreen(pubscreenadress))
  262.     {
  263.         were_on_public=TRUE;
  264.     }
  265.     else
  266.     {
  267.         pubscreenadress=0L;
  268.         my_pub_screen=IntuitionBase->FirstScreen;
  269.         were_on_public=FALSE;
  270.     }
  271.  
  272.     if(dftm.DisplayDIGITAL|dftm.DisplayDATE)
  273.     {
  274.          dummy_1=MAX(my_clock_font_1->tf_YSize,my_clock_font_2->tf_YSize)+BSPC;
  275.     }
  276.     else dummy_1=0L;
  277.  
  278.     numoflines=0;
  279.     if(dftm.DisplayAll)    numoflines++;
  280.     if(dftm.DisplayChip)   numoflines++;
  281.     if(dftm.DisplayFast)   numoflines++;
  282.     if(dftm.DisplayRetina) numoflines++;
  283.     if(dftm.DisplayInfo_1) numoflines++;
  284.     if(dftm.DisplayInfo_2) numoflines++;
  285.     if(dftm.DisplayIdle)   numoflines++;
  286.  
  287. /*    if(dftm.DisplayCarrier)numoflines++;*/
  288.     numoflines+=numofvols;
  289.  
  290.     win_height=(((gauge_y_size))*(((numoflines-1)/dftm.colums)+1))+(BSIZY*2)+(BSPC*((numoflines-1)/dftm.colums))+2+dummy_1;
  291.  
  292.     renew_temp_bitmaps(dftm.x_siz,win_height);
  293.  
  294.     open_new_window(dftm.x_pos,dftm.y_pos,dftm.x_siz,win_height);
  295.  
  296.     gauge_x_pos=0;
  297.     if(dftm.DisplayAll)    dogetwidesttext(&dftm.AllText[0]);
  298.     if(dftm.DisplayChip)   dogetwidesttext(&dftm.ChipText[0]);
  299.     if(dftm.DisplayFast)   dogetwidesttext(&dftm.FastText[0]);
  300.     if(dftm.DisplayRetina) dogetwidesttext(&dftm.RetinaText[0]);
  301.     for(k=0;k<numofvols;k++) dogetwidesttext(LoadedVolList[k]);
  302.  
  303.     get_min_size();
  304.     gauge_x_size    = ((my_window->Width)/dftm.colums)-gauge_x_pos-BSIZX;
  305.     for(k=0;k<dftm.colums;k++) xxpos[k]=(gauge_x_pos)*(k+1)+((BSIZX+gauge_x_size)*k)+1;
  306. }
  307.  
  308. load_font()
  309. {
  310.     struct  TextAttr      my_text_attr;
  311.     UBYTE   k;
  312.     UWORD   dummy;
  313.     struct  TextAttr      topaz_font =
  314.     {
  315.         "topaz.font",
  316.         8,
  317.         0,
  318.         FPF_ROMFONT,
  319.     };
  320.  
  321.     if(dftm.DisplayDIGITAL|dftm.DisplayDATE)
  322.     {
  323.         my_text_attr.ta_Name =(UBYTE *)&dftm.Clockfont_name[0];
  324.         my_text_attr.ta_YSize=(UWORD)dftm.Clockfont_size;
  325.         my_text_attr.ta_Flags=FPF_DISKFONT;
  326.         my_clock_font_1=(struct TextFont *) OpenDiskFont( &my_text_attr );
  327.  
  328.         my_text_attr.ta_Name =(UBYTE *)&dftm.Clocksmallfont_name[0];
  329.         my_text_attr.ta_YSize=(UWORD)dftm.Clocksmallfont_size;
  330.         my_text_attr.ta_Flags=FPF_DISKFONT;
  331.         my_clock_font_2=(struct TextFont *) OpenDiskFont( &my_text_attr );
  332.  
  333.         if(!my_clock_font_1)dftm.DisplayDIGITAL=FALSE;
  334.         if(!my_clock_font_2)dftm.DisplayDATE=FALSE;
  335.     }
  336.  
  337.     my_text_attr.ta_Name =(UBYTE *)&dftm.font_name[0];
  338.     my_text_attr.ta_YSize=(UWORD)dftm.font_size;
  339.     my_text_attr.ta_Flags=FPF_DISKFONT | FPB_PROPORTIONAL;
  340.  
  341.     my_text_font=(struct TextFont *)OpenDiskFont((struct TextAttr *)&my_text_attr );
  342.     if(!my_text_font)
  343.     {
  344.         my_text_font=(struct TextFont *) OpenFont( &topaz_font );
  345.         if(!my_text_font) { cleanexit();}
  346.     }
  347.     gauge_y_size    = ((my_text_font->tf_YSize)*(100+dftm.y_siz))/100;
  348.     texty           = ((gauge_y_size-my_text_font->tf_YSize)>>1)+my_text_font->tf_Baseline;
  349.     textdelta       = my_text_font->tf_YSize-my_text_font->tf_Baseline+1;
  350.     dftm.BorderY    = dftm.BorderY < textdelta ? textdelta : dftm.BorderY;
  351.     space           = BSPC+(gauge_y_size);
  352.     for(k=0;k<32;k++)
  353.         yypos[k]    = (UWORD)space*k + ( ( dftm.ClockIndent & 16 ) ? MAX( my_clock_font_1 ? my_clock_font_1->tf_YSize + BSPC : 0,my_clock_font_2 ? my_clock_font_2->tf_YSize + BSPC : 0) : 0 );
  354.     gauge_y_pos_2   = BSIZY-1+(gauge_y_size);
  355. }
  356.  
  357. load_background()
  358. {
  359.     if (my_dtobject = (Object *)NewDTObject(&dftm.background_picture[0],
  360.                                             DTA_SourceType       ,DTST_FILE,
  361.                                             DTA_GroupID          ,GID_PICTURE,
  362.                                             PDTA_Remap           ,TRUE,
  363.                                             PDTA_Screen          ,my_window->WScreen,
  364.                                             PDTA_FreeSourceBitMap,TRUE,
  365.                                             OBP_Precision        ,PRECISION_IMAGE,
  366.                                             TAG_DONE))
  367.     {
  368.         if ( DoDTMethod(my_dtobject,NULL,NULL,DTM_PROCLAYOUT,NULL,1))
  369.         {
  370.             GetDTAttrs(my_dtobject,PDTA_BitMapHeader,&my_header,PDTA_DestBitMap,&my_bitmap,TAG_DONE);
  371.             if (my_bitmap==FALSE) GetDTAttrs(my_dtobject,PDTA_BitMap,&my_bitmap,TAG_DONE);
  372.         }
  373.     }
  374. }
  375.  
  376. free_background()
  377. {
  378.     if(my_dtobject) DisposeDTObject((Object *)my_dtobject);
  379.     my_dtobject=0L; my_bitmap=0L;
  380. }
  381.  
  382. new_window_size()
  383. {
  384.     renew_temp_bitmaps(my_window->Width,my_window->Height);
  385.     my_drag.Width   =my_window->Width;
  386.     my_drag.Height  =my_window->Height-17;
  387.     my_size.TopEdge =my_window->Height-16;
  388.     my_size.LeftEdge=my_window->Width -16;
  389. }
  390.  
  391. free_all()
  392. {
  393.     if(were_on_public)  UnlockPubScreen (0,my_pub_screen);
  394.     if(my_window)
  395.     {
  396.         RemoveGList(my_window,my_window->FirstGadget,-1);
  397.         CloseWindow     (my_window);
  398.     }
  399.     if(my_text_font)    CloseFont       (my_text_font);
  400.     if(my_clock_font_1) CloseFont       (my_clock_font_1);
  401.     if(my_clock_font_2) CloseFont       (my_clock_font_2);
  402.     if(my_b1)           FreeBitMap      (my_b1);
  403.     if(my_b2)           FreeBitMap      (my_b2);
  404.     if(my_bitmap)       free_background();
  405.     my_clock_font_2 =0L;
  406.     my_clock_font_1 =0L;
  407.     my_text_font    =0L;
  408.     my_window       =0L;
  409.     my_b1           =0L;
  410.     my_b2           =0L;
  411.     freevols();
  412. /*    free_serial();*/
  413. }
  414.  
  415. cleanexit()
  416. {
  417.     free_all();
  418.     exit(1);
  419. }
  420.  
  421. makeall()
  422. {
  423.     if(!InitIdle & dftm.DisplayIdle)
  424.     {
  425.         init_idle();
  426.         InitIdle=TRUE;
  427.     }
  428.     loadvols();
  429.     getvolsizes(0);
  430.     getvolsizes(1);
  431.     getvolsizes(2);
  432.     load_font();
  433.     open_window();
  434.     draw_borders_and_background();
  435.     get_avail_ram_and_display(2,numofvols);
  436.     DateStamp(&dt.dat_Stamp);
  437.     DisplayCLOCK(&dt,((numoflines-1)/dftm.colums)+1);
  438. }
  439.  
  440.  
  441.